home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / enable.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  17KB  |  658 lines
  1. /* $Id: enable.c,v 3.4 1998/03/28 03:58:30 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: enable.c,v $
  26.  * Revision 3.4  1998/03/28 03:58:30  brianp
  27.  * removed unneeded break
  28.  *
  29.  * Revision 3.3  1998/02/20 04:50:44  brianp
  30.  * implemented GL_SGIS_multitexture
  31.  *
  32.  * Revision 3.2  1998/02/08 20:18:20  brianp
  33.  * removed unneeded headers
  34.  *
  35.  * Revision 3.1  1998/02/01 16:37:19  brianp
  36.  * added GL_EXT_rescale_normal extension
  37.  *
  38.  * Revision 3.0  1998/01/31 20:51:23  brianp
  39.  * initial rev
  40.  *
  41.  */
  42.  
  43.  
  44. #ifdef PC_HEADER
  45. #include "all.h"
  46. #else
  47. #include <string.h>
  48. #include "context.h"
  49. #include "enable.h"
  50. #include "light.h"
  51. #include "macros.h"
  52. #include "types.h"
  53. #include "vbfill.h"
  54. #endif
  55.  
  56.  
  57.  
  58. /*
  59.  * Perform glEnable and glDisable calls.
  60.  */
  61. static void gl_enable( GLcontext* ctx, GLenum cap, GLboolean state )
  62. {
  63.    GLuint texSet = ctx->Texture.CurrentSet;
  64.    GLuint p;
  65.  
  66.    if (INSIDE_BEGIN_END(ctx)) {
  67.       if (state) {
  68.      gl_error( ctx, GL_INVALID_OPERATION, "glEnable" );
  69.       }
  70.       else {
  71.      gl_error( ctx, GL_INVALID_OPERATION, "glDisable" );
  72.       }
  73.       return;
  74.    }
  75.  
  76.    switch (cap) {
  77.       case GL_ALPHA_TEST:
  78.      if (ctx->Color.AlphaEnabled!=state) {
  79.         ctx->Color.AlphaEnabled = state;
  80.         ctx->NewState |= NEW_RASTER_OPS;
  81.      }
  82.      break;
  83.       case GL_AUTO_NORMAL:
  84.      ctx->Eval.AutoNormal = state;
  85.      break;
  86.       case GL_BLEND:
  87.      if (ctx->Color.BlendEnabled!=state) {
  88.         ctx->Color.BlendEnabled = state;
  89.         /* The following needed to accomodate 1.0 RGB logic op blending */
  90.         if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
  91.            ctx->Color.ColorLogicOpEnabled = GL_TRUE;
  92.         }
  93.         else {
  94.            ctx->Color.ColorLogicOpEnabled = GL_FALSE;
  95.         }
  96.         ctx->NewState |= NEW_RASTER_OPS;
  97.      }
  98.      break;
  99.       case GL_CLIP_PLANE0:
  100.       case GL_CLIP_PLANE1:
  101.       case GL_CLIP_PLANE2:
  102.       case GL_CLIP_PLANE3:
  103.       case GL_CLIP_PLANE4:
  104.       case GL_CLIP_PLANE5:
  105.      ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] = state;
  106.      /* Check if any clip planes enabled */
  107.      ctx->Transform.AnyClip = GL_FALSE;
  108.      for (p=0;p<MAX_CLIP_PLANES;p++) {
  109.         if (ctx->Transform.ClipEnabled[p]) {
  110.            ctx->Transform.AnyClip = GL_TRUE;
  111.            break;
  112.         }
  113.      }
  114.      break;
  115.       case GL_COLOR_MATERIAL:
  116.      if (ctx->Light.ColorMaterialEnabled!=state) {
  117.         ctx->Light.ColorMaterialEnabled = state;
  118.         if (state) {
  119.            GLfloat color[4];
  120.            color[0] = ctx->Current.ByteColor[0] * (1.0F / 255.0F);
  121.            color[1] = ctx->Current.ByteColor[1] * (1.0F / 255.0F);
  122.            color[2] = ctx->Current.ByteColor[2] * (1.0F / 255.0F);
  123.            color[3] = ctx->Current.ByteColor[3] * (1.0F / 255.0F);
  124.            /* update material with current color */
  125.            gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
  126.         }
  127.         gl_set_color_function(ctx);
  128.         ctx->NewState |= NEW_LIGHTING;
  129.      }
  130.      break;
  131.       case GL_CULL_FACE:
  132.      if (ctx->Polygon.CullFlag!=state) {
  133.         ctx->Polygon.CullFlag = state;
  134.         ctx->NewState |= NEW_POLYGON;
  135.      }
  136.      break;
  137.       case GL_DEPTH_TEST:
  138.      if (state && ctx->Visual->DepthBits==0) {
  139.         gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
  140.         return;
  141.      }
  142.      if (ctx->Depth.Test!=state) {
  143.         ctx->Depth.Test = state;
  144.         ctx->NewState |= NEW_RASTER_OPS;
  145.      }
  146.      break;
  147.       case GL_DITHER:
  148.      if (ctx->NoDither) {
  149.         /* MESA_NO_DITHER env var */
  150.         state = GL_FALSE;
  151.      }
  152.      if (ctx->Color.DitherFlag!=state) {
  153.         ctx->Color.DitherFlag = state;
  154.         ctx->NewState |= NEW_RASTER_OPS;
  155.      }
  156.      break;
  157.       case GL_FOG:
  158.      if (ctx->Fog.Enabled!=state) {
  159.         ctx->Fog.Enabled = state;
  160.         ctx->NewState |= NEW_RASTER_OPS;
  161.      }
  162.      break;
  163.       case GL_LIGHT0:
  164.       case GL_LIGHT1:
  165.       case GL_LIGHT2:
  166.       case GL_LIGHT3:
  167.       case GL_LIGHT4:
  168.       case GL_LIGHT5:
  169.       case GL_LIGHT6:
  170.       case GL_LIGHT7:
  171.      ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
  172.      ctx->NewState |= NEW_LIGHTING;
  173.      break;
  174.       case GL_LIGHTING:
  175.      if (ctx->Light.Enabled!=state) {
  176.         ctx->Light.Enabled = state;
  177.         ctx->NewState |= NEW_LIGHTING;
  178.      }
  179.      break;
  180.       case GL_LINE_SMOOTH:
  181.      if (ctx->Line.SmoothFlag!=state) {
  182.         ctx->Line.SmoothFlag = state;
  183.         ctx->NewState |= NEW_RASTER_OPS;
  184.      }
  185.      break;
  186.       case GL_LINE_STIPPLE:
  187.      if (ctx->Line.StippleFlag!=state) {
  188.         ctx->Line.StippleFlag = state;
  189.         ctx->NewState |= NEW_RASTER_OPS;
  190.      }
  191.      break;
  192.       case GL_INDEX_LOGIC_OP:
  193.      if (ctx->Color.IndexLogicOpEnabled!=state) {
  194.         ctx->NewState |= NEW_RASTER_OPS;
  195.      }
  196.      ctx->Color.IndexLogicOpEnabled = state;
  197.      break;
  198.       case GL_COLOR_LOGIC_OP:
  199.      if (ctx->Color.ColorLogicOpEnabled!=state) {
  200.         ctx->NewState |= NEW_RASTER_OPS;
  201.      }
  202.      ctx->Color.ColorLogicOpEnabled = state;
  203.      break;
  204.       case GL_MAP1_COLOR_4:
  205.      ctx->Eval.Map1Color4 = state;
  206.      break;
  207.       case GL_MAP1_INDEX:
  208.      ctx->Eval.Map1Index = state;
  209.      break;
  210.       case GL_MAP1_NORMAL:
  211.      ctx->Eval.Map1Normal = state;
  212.      break;
  213.       case GL_MAP1_TEXTURE_COORD_1:
  214.      ctx->Eval.Map1TextureCoord1 = state;
  215.      break;
  216.       case GL_MAP1_TEXTURE_COORD_2:
  217.      ctx->Eval.Map1TextureCoord2 = state;
  218.      break;
  219.       case GL_MAP1_TEXTURE_COORD_3:
  220.      ctx->Eval.Map1TextureCoord3 = state;
  221.      break;
  222.       case GL_MAP1_TEXTURE_COORD_4:
  223.      ctx->Eval.Map1TextureCoord4 = state;
  224.      break;
  225.       case GL_MAP1_VERTEX_3:
  226.      ctx->Eval.Map1Vertex3 = state;
  227.      break;
  228.       case GL_MAP1_VERTEX_4:
  229.      ctx->Eval.Map1Vertex4 = state;
  230.      break;
  231.       case GL_MAP2_COLOR_4:
  232.      ctx->Eval.Map2Color4 = state;
  233.      break;
  234.       case GL_MAP2_INDEX:
  235.      ctx->Eval.Map2Index = state;
  236.      break;
  237.       case GL_MAP2_NORMAL:
  238.      ctx->Eval.Map2Normal = state;
  239.      break;
  240.       case GL_MAP2_TEXTURE_COORD_1: 
  241.      ctx->Eval.Map2TextureCoord1 = state;
  242.      break;
  243.       case GL_MAP2_TEXTURE_COORD_2:
  244.      ctx->Eval.Map2TextureCoord2 = state;
  245.      break;
  246.       case GL_MAP2_TEXTURE_COORD_3:
  247.      ctx->Eval.Map2TextureCoord3 = state;
  248.      break;
  249.       case GL_MAP2_TEXTURE_COORD_4:
  250.      ctx->Eval.Map2TextureCoord4 = state;
  251.      break;
  252.       case GL_MAP2_VERTEX_3:
  253.      ctx->Eval.Map2Vertex3 = state;
  254.      break;
  255.       case GL_MAP2_VERTEX_4:
  256.      ctx->Eval.Map2Vertex4 = state;
  257.      break;
  258.       case GL_NORMALIZE:
  259.      ctx->Transform.Normalize = state;
  260.      break;
  261.       case GL_POINT_SMOOTH:
  262.      if (ctx->Point.SmoothFlag!=state) {
  263.         ctx->Point.SmoothFlag = state;
  264.         ctx->NewState |= NEW_RASTER_OPS;
  265.      }
  266.      break;
  267.       case GL_POLYGON_SMOOTH:
  268.      if (ctx->Polygon.SmoothFlag!=state) {
  269.         ctx->Polygon.SmoothFlag = state;
  270.         ctx->NewState |= NEW_RASTER_OPS;
  271.      }
  272.      break;
  273.       case GL_POLYGON_STIPPLE:
  274.      if (ctx->Polygon.StippleFlag!=state) {
  275.         ctx->Polygon.StippleFlag = state;
  276.         ctx->NewState |= NEW_RASTER_OPS;
  277.      }
  278.      break;
  279.       case GL_POLYGON_OFFSET_POINT:
  280.      if (ctx->Polygon.OffsetPoint!=state) {
  281.         ctx->Polygon.OffsetPoint = state;
  282.         ctx->NewState |= NEW_POLYGON;
  283.      }
  284.      break;
  285.       case GL_POLYGON_OFFSET_LINE:
  286.      if (ctx->Polygon.OffsetLine!=state) {
  287.         ctx->Polygon.OffsetLine = state;
  288.         ctx->NewState |= NEW_POLYGON;
  289.      }
  290.      break;
  291.       case GL_POLYGON_OFFSET_FILL:
  292.       /*case GL_POLYGON_OFFSET_EXT:*/
  293.      if (ctx->Polygon.OffsetFill!=state) {
  294.         ctx->Polygon.OffsetFill = state;
  295.         ctx->NewState |= NEW_POLYGON;
  296.      }
  297.      break;
  298.       case GL_RESCALE_NORMAL_EXT:
  299.      ctx->Transform.RescaleNormals = state;
  300.      break;
  301.       case GL_SCISSOR_TEST:
  302.      if (ctx->Scissor.Enabled!=state) {
  303.         ctx->Scissor.Enabled = state;
  304.         ctx->NewState |= NEW_RASTER_OPS;
  305.      }
  306.      break;
  307.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  308.      ctx->Texture.SharedPalette = state;
  309.      if (ctx->Driver.UseGlobalTexturePalette)
  310.         (*ctx->Driver.UseGlobalTexturePalette)( ctx, state );
  311.      break;
  312.       case GL_STENCIL_TEST:
  313.      if (state && ctx->Visual->StencilBits==0) {
  314.         gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
  315.         return;
  316.      }
  317.      if (ctx->Stencil.Enabled!=state) {
  318.         ctx->Stencil.Enabled = state;
  319.         ctx->NewState |= NEW_RASTER_OPS;
  320.      }
  321.      break;
  322.       case GL_TEXTURE_1D:
  323.      if (ctx->Visual->RGBAflag) {
  324.         /* texturing only works in RGB mode */
  325.         GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  326.         if (state) {
  327.            ctx->Texture.Enabled |= bit;
  328.         }
  329.         else {
  330.            ctx->Texture.Enabled &= (~bit);
  331.         }
  332.         ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  333.      }
  334.      break;
  335.       case GL_TEXTURE_2D:
  336.      if (ctx->Visual->RGBAflag) {
  337.         /* texturing only works in RGB mode */
  338.         GLuint bit = TEXTURE0_2D << (ctx->Texture.CurrentSet * 4);
  339.         if (state) {
  340.            ctx->Texture.Enabled |= bit;
  341.         }
  342.         else {
  343.            ctx->Texture.Enabled &= (~bit);
  344.         }
  345.         ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  346.      }
  347.      break;
  348.       case GL_TEXTURE_3D_EXT:
  349.      if (ctx->Visual->RGBAflag) {
  350.         /* texturing only works in RGB mode */
  351.         GLuint bit = TEXTURE0_3D << (ctx->Texture.CurrentSet * 4);
  352.         if (state) {
  353.            ctx->Texture.Enabled |= bit;
  354.         }
  355.         else {
  356.            ctx->Texture.Enabled &= (~bit);
  357.         }
  358.         ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  359.      }
  360.      break;
  361.       case GL_TEXTURE_GEN_Q:
  362.      if (state) {
  363.         ctx->Texture.Set[texSet].TexGenEnabled |= Q_BIT;
  364.      }
  365.      else {
  366.         ctx->Texture.Set[texSet].TexGenEnabled &= ~Q_BIT;
  367.      }
  368.      ctx->NewState |= NEW_TEXTURING;
  369.      break;
  370.       case GL_TEXTURE_GEN_R:
  371.      if (state) {
  372.         ctx->Texture.Set[texSet].TexGenEnabled |= R_BIT;
  373.      }
  374.      else {
  375.         ctx->Texture.Set[texSet].TexGenEnabled &= ~R_BIT;
  376.      }
  377.      ctx->NewState |= NEW_TEXTURING;
  378.      break;
  379.       case GL_TEXTURE_GEN_S:
  380.      if (state) {
  381.         ctx->Texture.Set[texSet].TexGenEnabled |= S_BIT;
  382.      }
  383.      else {
  384.         ctx->Texture.Set[texSet].TexGenEnabled &= ~S_BIT;
  385.      }
  386.      ctx->NewState |= NEW_TEXTURING;
  387.      break;
  388.       case GL_TEXTURE_GEN_T:
  389.      if (state) {
  390.         ctx->Texture.Set[texSet].TexGenEnabled |= T_BIT;
  391.      }
  392.      else {
  393.         ctx->Texture.Set[texSet].TexGenEnabled &= ~T_BIT;
  394.      }
  395.      ctx->NewState |= NEW_TEXTURING;
  396.      break;
  397.  
  398.       /*
  399.        * CLIENT STATE!!!
  400.        */
  401.       case GL_VERTEX_ARRAY:
  402.      ctx->Array.VertexEnabled = state;
  403.      break;
  404.       case GL_NORMAL_ARRAY:
  405.      ctx->Array.NormalEnabled = state;
  406.      break;
  407.       case GL_COLOR_ARRAY:
  408.      ctx->Array.ColorEnabled = state;
  409.      break;
  410.       case GL_INDEX_ARRAY:
  411.      ctx->Array.IndexEnabled = state;
  412.      break;
  413.       case GL_TEXTURE_COORD_ARRAY:
  414.      ctx->Array.TexCoordEnabled[texSet] = state;
  415.      break;
  416.       case GL_EDGE_FLAG_ARRAY:
  417.      ctx->Array.EdgeFlagEnabled = state;
  418.      break;
  419.  
  420.       default:
  421.      if (state) {
  422.         gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
  423.      }
  424.      else {
  425.         gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
  426.      }
  427.      break;
  428.    }
  429. }
  430.  
  431.  
  432.  
  433.  
  434. void gl_Enable( GLcontext* ctx, GLenum cap )
  435. {
  436.    gl_enable( ctx, cap, GL_TRUE );
  437. }
  438.  
  439.  
  440.  
  441. void gl_Disable( GLcontext* ctx, GLenum cap )
  442. {
  443.    gl_enable( ctx, cap, GL_FALSE );
  444. }
  445.  
  446.  
  447.  
  448. GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
  449. {
  450.    switch (cap) {
  451.       case GL_ALPHA_TEST:
  452.      return ctx->Color.AlphaEnabled;
  453.       case GL_AUTO_NORMAL:
  454.      return ctx->Eval.AutoNormal;
  455.       case GL_BLEND:
  456.      return ctx->Color.BlendEnabled;
  457.       case GL_CLIP_PLANE0:
  458.       case GL_CLIP_PLANE1:
  459.       case GL_CLIP_PLANE2:
  460.       case GL_CLIP_PLANE3:
  461.       case GL_CLIP_PLANE4:
  462.       case GL_CLIP_PLANE5:
  463.      return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
  464.       case GL_COLOR_MATERIAL:
  465.      return ctx->Light.ColorMaterialEnabled;
  466.       case GL_CULL_FACE:
  467.      return ctx->Polygon.CullFlag;
  468.       case GL_DEPTH_TEST:
  469.      return ctx->Depth.Test;
  470.       case GL_DITHER:
  471.      return ctx->Color.DitherFlag;
  472.       case GL_FOG:
  473.      return ctx->Fog.Enabled;
  474.       case GL_LIGHTING:
  475.      return ctx->Light.Enabled;
  476.       case GL_LIGHT0:
  477.       case GL_LIGHT1:
  478.       case GL_LIGHT2:
  479.       case GL_LIGHT3:
  480.       case GL_LIGHT4:
  481.       case GL_LIGHT5:
  482.       case GL_LIGHT6:
  483.       case GL_LIGHT7:
  484.      return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
  485.       case GL_LINE_SMOOTH:
  486.      return ctx->Line.SmoothFlag;
  487.       case GL_LINE_STIPPLE:
  488.      return ctx->Line.StippleFlag;
  489.       case GL_INDEX_LOGIC_OP:
  490.      return ctx->Color.IndexLogicOpEnabled;
  491.       case GL_COLOR_LOGIC_OP:
  492.      return ctx->Color.ColorLogicOpEnabled;
  493.       case GL_MAP1_COLOR_4:
  494.      return ctx->Eval.Map1Color4;
  495.       case GL_MAP1_INDEX:
  496.      return ctx->Eval.Map1Index;
  497.       case GL_MAP1_NORMAL:
  498.      return ctx->Eval.Map1Normal;
  499.       case GL_MAP1_TEXTURE_COORD_1:
  500.      return ctx->Eval.Map1TextureCoord1;
  501.       case GL_MAP1_TEXTURE_COORD_2:
  502.      return ctx->Eval.Map1TextureCoord2;
  503.       case GL_MAP1_TEXTURE_COORD_3:
  504.      return ctx->Eval.Map1TextureCoord3;
  505.       case GL_MAP1_TEXTURE_COORD_4:
  506.      return ctx->Eval.Map1TextureCoord4;
  507.       case GL_MAP1_VERTEX_3:
  508.      return ctx->Eval.Map1Vertex3;
  509.       case GL_MAP1_VERTEX_4:
  510.      return ctx->Eval.Map1Vertex4;
  511.       case GL_MAP2_COLOR_4:
  512.      return ctx->Eval.Map2Color4;
  513.       case GL_MAP2_INDEX:
  514.      return ctx->Eval.Map2Index;
  515.       case GL_MAP2_NORMAL:
  516.      return ctx->Eval.Map2Normal;
  517.       case GL_MAP2_TEXTURE_COORD_1: 
  518.      return ctx->Eval.Map2TextureCoord1;
  519.       case GL_MAP2_TEXTURE_COORD_2:
  520.      return ctx->Eval.Map2TextureCoord2;
  521.       case GL_MAP2_TEXTURE_COORD_3:
  522.      return ctx->Eval.Map2TextureCoord3;
  523.       case GL_MAP2_TEXTURE_COORD_4:
  524.      return ctx->Eval.Map2TextureCoord4;
  525.       case GL_MAP2_VERTEX_3:
  526.      return ctx->Eval.Map2Vertex3;
  527.       case GL_MAP2_VERTEX_4:
  528.      return ctx->Eval.Map2Vertex4;
  529.       case GL_NORMALIZE:
  530.      return ctx->Transform.Normalize;
  531.       case GL_POINT_SMOOTH:
  532.      return ctx->Point.SmoothFlag;
  533.       case GL_POLYGON_SMOOTH:
  534.      return ctx->Polygon.SmoothFlag;
  535.       case GL_POLYGON_STIPPLE:
  536.      return ctx->Polygon.StippleFlag;
  537.       case GL_POLYGON_OFFSET_POINT:
  538.      return ctx->Polygon.OffsetPoint;
  539.       case GL_POLYGON_OFFSET_LINE:
  540.      return ctx->Polygon.OffsetLine;
  541.       case GL_POLYGON_OFFSET_FILL:
  542.       /*case GL_POLYGON_OFFSET_EXT:*/
  543.      return ctx->Polygon.OffsetFill;
  544.       case GL_RESCALE_NORMAL_EXT:
  545.      return ctx->Transform.RescaleNormals;
  546.       case GL_SCISSOR_TEST:
  547.      return ctx->Scissor.Enabled;
  548.       case GL_SHARED_TEXTURE_PALETTE_EXT:
  549.      return ctx->Texture.SharedPalette;
  550.       case GL_STENCIL_TEST:
  551.      return ctx->Stencil.Enabled;
  552.       case GL_TEXTURE_1D:
  553.      {
  554.         GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  555.         return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  556.      }
  557.       case GL_TEXTURE_2D:
  558.      {
  559.         GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  560.         return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  561.      }
  562.       case GL_TEXTURE_3D_EXT:
  563.      {
  564.         GLuint bit = TEXTURE0_1D << (ctx->Texture.CurrentSet * 4);
  565.         return (ctx->Texture.Enabled & bit) ? GL_TRUE : GL_FALSE;
  566.      }
  567.       case GL_TEXTURE_GEN_Q:
  568.      {
  569.         const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  570.         return (texSet->TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  571.      }
  572.       case GL_TEXTURE_GEN_R:
  573.      {
  574.         const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  575.         return (texSet->TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  576.      }
  577.       case GL_TEXTURE_GEN_S:
  578.      {
  579.         const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  580.         return (texSet->TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  581.      }
  582.       case GL_TEXTURE_GEN_T:
  583.      {
  584.         const struct gl_texture_set *texSet = &ctx->Texture.Set[ctx->Texture.CurrentSet];
  585.         return (texSet->TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  586.      }
  587.  
  588.       /*
  589.        * CLIENT STATE!!!
  590.        */
  591.       case GL_VERTEX_ARRAY:
  592.      return ctx->Array.VertexEnabled;
  593.       case GL_NORMAL_ARRAY:
  594.      return ctx->Array.NormalEnabled;
  595.       case GL_COLOR_ARRAY:
  596.      return ctx->Array.ColorEnabled;
  597.       case GL_INDEX_ARRAY:
  598.      return ctx->Array.IndexEnabled;
  599.       case GL_TEXTURE_COORD_ARRAY:
  600.      {
  601.         GLuint texSet = ctx->Texture.CurrentSet;
  602.         return ctx->Array.TexCoordEnabled[texSet];
  603.      }
  604.       case GL_EDGE_FLAG_ARRAY:
  605.      return ctx->Array.EdgeFlagEnabled;
  606.       default:
  607.      gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
  608.      return GL_FALSE;
  609.    }
  610. }
  611.  
  612.  
  613.  
  614.  
  615. void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  616. {
  617.    switch (cap) {
  618.       case GL_VERTEX_ARRAY:
  619.      ctx->Array.VertexEnabled = state;
  620.      break;
  621.       case GL_NORMAL_ARRAY:
  622.      ctx->Array.NormalEnabled = state;
  623.      break;
  624.       case GL_COLOR_ARRAY:
  625.      ctx->Array.ColorEnabled = state;
  626.      break;
  627.       case GL_INDEX_ARRAY:
  628.      ctx->Array.IndexEnabled = state;
  629.      break;
  630.       case GL_TEXTURE_COORD_ARRAY:
  631.      {
  632.         GLuint texSet = ctx->Texture.CurrentSet;
  633.         ctx->Array.TexCoordEnabled[texSet] = state;
  634.      }
  635.      break;
  636.       case GL_EDGE_FLAG_ARRAY:
  637.      ctx->Array.EdgeFlagEnabled = state;
  638.      break;
  639.       default:
  640.      gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
  641.    }
  642. }
  643.  
  644.  
  645.  
  646. void gl_EnableClientState( GLcontext *ctx, GLenum cap )
  647. {
  648.    gl_client_state( ctx, cap, GL_TRUE );
  649. }
  650.  
  651.  
  652.  
  653. void gl_DisableClientState( GLcontext *ctx, GLenum cap )
  654. {
  655.    gl_client_state( ctx, cap, GL_FALSE );
  656. }
  657.  
  658.